`:top

En `F33f`_`[programmation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation]`_`f `F33f`_`[informatique`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Informatique]`_`f, `!l'optimisation de code`! est la pratique consistant à améliorer l'efficacité du `F33f`_`[code informatique`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Code_informatique]`_`f d'un programme ou d'une bibliothèque logicielle. Ces améliorations permettent généralement au programme résultant de s'exécuter plus rapidement, de prendre moins de place en `F33f`_`[mémoire`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mémoire_(informatique)]`_`f, de limiter sa consommation de ressources (par exemple les `F33f`_`[fichiers`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Fichier_informatique]`_`f), ou de consommer moins d'`F33f`_`[énergie électrique`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Énergie_électrique]`_`f.

>>Contents

• `F0af`_`[Principes d'optimisation`#principes-d-optimisation]`_`f

• `F0af`_`[Pratique de l'optimisation`#pratique-de-l-optimisation]`_`f

• `F0af`_`[Localisation du code à optimiser`#localisation-du-code-optimiser]`_`f

• `F0af`_`[Différentes approches d’optimisation`#diff-rentes-approches-d-optimisation]`_`f

• `F0af`_`[Optimisation automatique`#optimisation-automatique]`_`f

• `F0af`_`[Exemples`#exemples]`_`f

• `F0af`_`[Notes et références`#notes-et-r-f-rences]`_`f

• `F0af`_`[Voir aussi`#voir-aussi]`_`f

• `F0af`_`[Liens externes`#liens-externes]`_`f

-─

>>Principes d'optimisation

La règle numéro un de l'optimisation est qu'`*elle ne doit intervenir qu'une fois que le programme fonctionne et répond aux spécifications fonctionnelles`*. L'expérience montre qu'appliquer des optimisations de bas niveau du code avant que ces deux conditions ne soient réalisées revient le plus souvent à une perte de temps et s'avère néfaste à la clarté du code et au bon fonctionnement du programme :

`*« L'optimisation prématurée est la source de tous les maux. »`*

— `F33f`_`[Donald Knuth`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Donald_Knuth]`_`f, citant `F33f`_`[Dijkstra`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Edsger_Dijkstra]`_`f

Cependant cette citation, tronquée, est très souvent mal interprétée. La version complète étant :

`*« On devrait oublier les petites optimisations locales, disons, 97 % du temps : l'optimisation prématurée est la source de tous les maux`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f]. »`*

— `F33f`_`[Donald Knuth`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Donald_Knuth]`_`f

La citation originale indique que généralement durant l'écriture d'un code, on peut laisser de côté les optimisations locales, de bas niveau (réécriture en assembleur, `F33f`_`[déroulage de boucle`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Déroulage_de_boucle]`_`f, etc.). Il est possible d'interpréter cette citation en déduisant de celle-ci que les optimisations de haut niveau concernant le choix des algorithmes ou l'architecture d'un projet doivent venir avant celle de bas niveau. Ainsi, ce n'est que vers la fin de l'écriture du programme, une fois que l'analyse montre qu'un détail de bas niveau est critique qu'il peut éventuellement être nécessaire de le modifier :

`*« What Hoare and Knuth are really saying is that software engineers should worry about other issues (such as good algorithm design and good implementations of those algorithms) before they worry about micro-optimizations such as how many CPU cycles a particular statement consumes. »`*

— Randall Hyde, ACM Ubiquity Vol. 10, Issue 3

Au contraire plus le projet grandit et plus ces optimisations de haut niveau seront difficiles, coûteuses (en termes de temps, difficulté et budget) voire impossibles à effectuer.

La plupart des `F33f`_`[compilateurs`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Compilateur]`_`f récents pratiquent de façon automatique un certain nombre d'optimisations qu'il serait fastidieux d'effectuer `*manuellement`* et qui rendraient le `F33f`_`[code source`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Code_source]`_`f moins `F33f`_`[lisible`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Lisibilité_(programmation)]`_`f.

L'optimisation manuelle locale peut s'avérer nécessaire dans des cas très spécifiques, mais les mesures montrent que sur des machines `F33f`_`[RISC`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Reduced_instruction_set_computer]`_`f qui possèdent un nombre élevé de `F33f`_`[registres`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Registre_(informatique)]`_`f et où l'efficacité demande le regroupement des instructions identiques pour bénéficier de l'effet `F33f`_`[pipeline`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Pipeline_(architecture_des_processeurs)]`_`f, l'optimiseur d'un compilateur C fournit souvent un code plus efficace que celui qui serait écrit en `F33f`_`[assembleur`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_assembleur]`_`f par un programmeur expérimenté (ce qui n'était jamais le cas sur les machines `F33f`_`[CISC`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Complex_instruction_set_computer]`_`f). Et de surcroit ce code est bien plus facile à maintenir, car les instructions en C restent dans un ordre lié à la seule intelligibilité du code et non aux spécificités de la machine : dans les optimiseurs actuels, en effet, les ordres machines associés à une instruction ne se trouvent plus nécessairement en position contiguë, pour des raisons d'efficacité d'exécution. Cela rend le code assembleur généré particulièrement indéchiffrable.

>>Pratique de l'optimisation

Pour suivre l’efficacité d’une optimisation, le développeur s’appuie sur des `F33f`_`[tests de performance`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Test_de_performance]`_`f, c’est-à-dire sur des mesures objectives du temps de traitement et de la taille de la `F33f`_`[mémoire`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mémoire_vive]`_`f `F33f`_`[allouée`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Allocation_de_mémoire]`_`f.

La réduction de la `F33f`_`[taille des données résidentes en mémoire`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Resident_set_size]`_`f est complexe puisque la libération d’une zone de mémoire permet rarement de rendre la mémoire disponible pour le système d’exploitation`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f].

>>>Localisation du code à optimiser

Pour évaluer le `F33f`_`[temps`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Worst_Case_Execution_Time]`_`f et la `F33f`_`[mémoire`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mémoire_virtuelle]`_`f nécessaire pour chaque partie du programme, les développeurs réalisent le `F33f`_`[profilage du code`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Profilage_de_code]`_`f. Il n'est pas rare qu’une grande partie du temps soit consacré à l'exécution d’un petit morceau du code, ce morceau de code est appelé « `F33f`_`[goulot d’étranglement`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Goulot_d'étranglement_(informatique)]`_`f ».

Le logiciel de profilage est chargé de compter le nombre d’exécutions de chaque fonction et de cycles du `F33f`_`[microprocesseur`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Microprocesseur]`_`f correspondants au cours de l'exécution.

>>>Différentes approches d’optimisation

Plusieurs approches existent pour optimiser un code :

• au niveau algorithmique, en choisissant un `F33f`_`[algorithme`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Algorithmique]`_`f de `F33f`_`[complexité mathématique`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Théorie_de_la_complexité_(informatique_théorique)]`_`f inférieure et des `F33f`_`[structures de données`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Structure_de_données]`_`f adaptées ;

• au niveau du `F33f`_`[langage de développement`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_de_programmation]`_`f, en ordonnant au mieux les instructions et en utilisant les bibliothèques disponibles ;

• en utilisant localement un `F33f`_`[langage de bas niveau`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_de_programmation_de_bas_niveau]`_`f, qui peut être le `F33f`_`[langage C`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C_(langage)]`_`f ou, pour les besoins les plus critiques, le `F33f`_`[langage assembleur`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_assembleur]`_`f.

>>>>Optimisation algorithmique

L’optimisation algorithmique consiste à appliquer au code des transformations mathématiques successives qui préservent la `F33f`_`[spécification`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Spécification_(norme_technique)]`_`f du programme tout en réduisant la consommation des ressources.

>>>>Optimisations grâce aux outils du langage

L’utilisation de `F33f`_`[fonctions`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Routine_(informatique)]`_`f différentes voire de `F33f`_`[bibliothèques`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Bibliothèque_logicielle]`_`f complètes différentes peut permettre une optimisation du programme.

>>>>Optimisation en changeant de langage utilisé

Dans la pratique, les applications comportant beaucoup d'`F33f`_`[entrées-sorties`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Entrées-sorties]`_`f lentes peuvent être optimisées en étant réécrites dans un `F33f`_`[langage`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_de_programmation]`_`f comme `F33f`_`[Haskell`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Haskell]`_`f ou `F33f`_`[Python`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Python_(langage)]`_`f.

Une application nécessitant beaucoup de calculs et d’`F33f`_`[affectations en mémoire`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Affectation_(informatique)]`_`f peut être optimisée en étant réécrite dans un langage tel que le C ou le C++.

>>Optimisation automatique

Les compilateurs sont souvent capables de faire des optimisations locales, auxquelles aucun développeur ne penserait en première approche.

Pour le langage C, cela peut concerner :

• les variables locales et les registres ;

• les fonctions non implémentées en assembleur en tant que fonction ;

• les `B100`F9d9switch`f`b, qui sont optimum.

Toutefois, on peut grandement aider le compilateur en déclarant les variables avec les mots-clefs `B100`F9d9const`f`b et/ou `B100`F9d9restrict`f`b quand c'est possible ; autrement, le compilateur ne peut savoir si une zone mémoire est accessible par d'autres références, et désactivera des optimisations (phénomène dit d'alias de mémoire).

Un profileur (ou un analyseur de performances) peut être utilisé pour trouver les sections du programme qui consomment le plus de ressources - le goulot d'étranglement`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f]. Les programmeurs peuvent avoir une idée erronée de l'endroit où se trouve le goulot d'étranglement. L'optimisation d'une partie mineure du code ne contribue généralement pas à améliorer les performances globales. Lorsque le goulet d'étranglement est localisé, l'optimisation commence généralement par un réexamen de l'algorithme utilisé dans le programme`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]. Le plus souvent, un algorithme particulier peut être spécifiquement adapté à une tâche particulière et offrir de meilleures performances qu'un algorithme générique. Par exemple, le tri d'une énorme liste d'éléments est généralement effectué à l'aide de la procédure de `F33f`_`[tri rapide`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Tri_rapide]`_`f, qui est l'un des algorithmes universels les plus efficaces. Mais si certaines caractéristiques des éléments peuvent être exploitées (par exemple, s'ils sont déjà rangés dans un ordre spécifique), une méthode différente ou même une procédure de tri spéciale peut être utilisée.

À partir de 2020, des programmes d'optimisation automatique des codes basés sur l'intelligence artificielle commenceront à être utilisés. En proposant différentes manières d'implémenter le code, les outils d'intelligence artificielle peuvent prendre en charge une partie des tâches de l'utilisateur`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]. Par exemple, ces réseaux neuronaux sont capables d'analyser le code, de corriger les erreurs, d'ajouter des lignes ou des branches entières de code`:cite-ref-8[`F5bf`_`[8`#cite-note-8]`_`f].

Une fois que le programmeur est suffisamment sûr d'avoir sélectionné le meilleur algorithme, l'optimisation du code peut commencer. Les boucles peuvent être étendues (pour réduire la surcharge des boucles, bien que cela puisse souvent entraîner une dégradation de la vitesse si cela surcharge la mémoire cache de l'unité centrale), le moins de `F33f`_`[types de données`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Type_(informatique)]`_`f possible peut être utilisé, l'arithmétique des nombres entiers peut être utilisée au lieu des opérations à virgule flottante, et ainsi de suite.

>>>Exemples

>>>>Utilisation de variables locales pour éviter les alias de mémoire

Le code C++ suivant sera en général peu optimisé par le compilateur car il est souvent incapable de savoir si le code de la boucle modifie ou non le compteur d'itérations : un pointeur ou une référence pourrait le modifier.

`B100`F9d9 void MyClass::DoSomething() const`f`b

`B100`F9d9 {`f`b

`B100`F9d9 for( int i=0; i<m_nbrElements; ++i )`f`b

`B100`F9d9 {`f`b

`B100`F9d9 void *ptr = GetSomePtr();`f`b

`B100`F9d9 ....`f`b

`B100`F9d9 }`f`b

`B100`F9d9 }`f`b

Dans cette version, on indique clairement qu'on utilise un nombre d'itérations fixé à l'avance et qui ne sera jamais modifié, autorisant le compilateur à effectuer des optimisations plus agressives :

`B100`F9d9 void MyClass::DoSomething()`f`b

`B100`F9d9 {`f`b

`B100`F9d9 const int nbrElements = m_nbrElements;`f`b

`B100`F9d9 for( int i=0; i<nbrElements; ++i )`f`b

`B100`F9d9 {`f`b

`B100`F9d9 ....`f`b

`B100`F9d9 }`f`b

`B100`F9d9 }`f`b

>>>>Une spécificité du binaire : le décalage

Une des toutes premières optimisations a été celle de la division et de la multiplication par une puissance de 2.

En effet, l'informatique actuelle repose sur le binaire, puisqu'elle utilise comme élément de base le `F33f`_`[transistor`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Transistor]`_`f (et historiquement, auparavant le `F33f`_`[relais`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Relais_électromécanique]`_`f) qui n'autorise que deux valeurs différentes.

On a donc logiquement implémenté en `F33f`_`[langage machine`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_machine]`_`f les opérations de décalage à gauche et décalage à droite.

En effet, en `F33f`_`[binaire`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Bit]`_`f, le décalage d'un nombre d'un cran vers la gauche le multiplie par 2.

Ainsi, 2 ( 10 2 {\\displaystyle 10_{2}} ) décalé de 1 bit donne 4 ( 100 2 {\\displaystyle 100_{2}} ).

5 ( 101 2 {\\displaystyle 101_{2}} ) décalé de 2 bits donne 20 ( 10100 2 {\\displaystyle 10100_{2}} ) : 5 ∗ ∗ 2 2 = 20 {\\displaystyle 5*2^{2}=20} .

Ceci marche aussi pour la division, en décalant les bits vers la droite.

100 ( 1100100 2 {\\displaystyle 1100100_{2}} ) décalé de 3 bits vers la droite donne 100 / 2 3 = 12.5 {\\displaystyle 100/2^{3}=12.5} donc 12 ( 1100 2 {\\displaystyle 1100_{2}} ) car nous travaillons sur des nombres entiers.

L'arithmétique entière d'un processeur est en fait l'arithmétique dans l'anneau des Z / 2 32 Z {\\displaystyle \\mathbb {Z} /2^{32}\\mathbb {Z} } par exemple. Et donc, tous les nombres premiers avec 2 32 {\\displaystyle 2^{32}} ont un inverse, et il est possible d'effectuer une division par l'un de ces nombres en une seule instruction. Par exemple, dans l'anneau des entiers sur 32 bits, diviser par 3 revient à multiplier par 2863311531. Diviser par 14 revient à multiplier par 3067833783 puis diviser par 2. C'est donc possible avec deux instructions. Les compilateurs savent faire ces optimisations mais pour cela le diviseur doit être connu à la compilation.

La division dans le cas général est une instruction coûteuse en temps machine, et n'est d'ailleurs toujours pas disponible sur la grande majorité des processeurs de type `F33f`_`[RISC`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Reduced_instruction_set_computer]`_`f.

>>>>Le mot clef inline du C

Le mot clef `*inline`* attaché à une fonction indique au compilateur qu'il devrait essayer d'`F33f`_`[étendre cette fonction`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Extension_inline]`_`f. Considérons par exemple le code C suivant :

`B100`F9d9 inline int f(int a, int b) {`f`b

`B100`F9d9 return a * b;`f`b

`B100`F9d9 }`f`b

`B100`F9d9`f`b

`B100`F9d9 int g (int a) {`f`b

`B100`F9d9 switch (a) {`f`b

`B100`F9d9 case 10:`f`b

`B100`F9d9 return f(a, a);`f`b

`B100`F9d9 case 11:`f`b

`B100`F9d9 case 12:`f`b

`B100`F9d9 return f(a - 2, a);`f`b

`B100`F9d9 case 1200:`f`b

`B100`F9d9 return f(a - 2, a);`f`b

`B100`F9d9 default:`f`b

`B100`F9d9 return f(a, a);`f`b

`B100`F9d9 }`f`b

`B100`F9d9 }`f`b

Une compilation avec gcc -O4 -S donne, en assembleur i386 :

`B100`F9d9 .file "opt.c"`f`b

`B100`F9d9 .text`f`b

`B100`F9d9 .p2align 4,,15`f`b

`B100`F9d9 .globl g`f`b

`B100`F9d9 .type g, @function`f`b

`B100`F9d9 g:`f`b

`B100`F9d9 pushl %ebp`f`b

`B100`F9d9 movl %esp, %ebp`f`b

`B100`F9d9 movl 8(%ebp), %edx`f`b

`B100`F9d9 cmpl $12, %edx`f`b

`B100`F9d9 jg .L14`f`b

`B100`F9d9 leal -2(%edx), %eax`f`b

`B100`F9d9 cmpl $11, %edx`f`b

`B100`F9d9 jge .L15`f`b

`B100`F9d9 movl $100, %eax`f`b

`B100`F9d9 cmpl $10, %edx`f`b

`B100`F9d9 .L17:`f`b

`B100`F9d9 je .L2`f`b

`B100`F9d9 movl %edx, %eax`f`b

`B100`F9d9 .L15:`f`b

`B100`F9d9 imull %edx, %eax`f`b

`B100`F9d9 .L2:`f`b

`B100`F9d9 popl %ebp`f`b

`B100`F9d9 ret`f`b

`B100`F9d9 .p2align 4,,7`f`b

`B100`F9d9 .L14:`f`b

`B100`F9d9 movl $1437600, %eax`f`b

`B100`F9d9 cmpl $1200, %edx`f`b

`B100`F9d9 jmp .L17`f`b

`B100`F9d9 .size g, .-g`f`b

`B100`F9d9 .section .note.GNU-stack,"",@progbits`f`b

`B100`F9d9 .ident "GCC: (GNU) 3.3.2 (Mandrake Linux 10.0 3.3.2-6mdk)"`f`b

Ce qui pourrait se traduire, pour une compréhension plus aisée, par le code C suivant :

`B100`F9d9 int g(int a) {`f`b

`B100`F9d9`f`b

`B100`F9d9 int eax, b;`f`b

`B100`F9d9`f`b

`B100`F9d9 if (a > 12) /* cas a == 1200 */`f`b

`B100`F9d9 goto L14;`f`b

`B100`F9d9`f`b

`B100`F9d9 eax = a - 2;`f`b

`B100`F9d9 if (a >= 11) /* cas a == 11 ou a == 12 */`f`b

`B100`F9d9 goto L15;`f`b

`B100`F9d9`f`b

`B100`F9d9 eax=100; /* = 10 * 10 */`f`b

`B100`F9d9 b=10;`f`b

`B100`F9d9`f`b

`B100`F9d9 L17:`f`b

`B100`F9d9 if (a == b) /* cas a == 10 */`f`b

`B100`F9d9 goto L2;`f`b

`B100`F9d9 /* cas "default" */`f`b

`B100`F9d9 eax=a;`f`b

`B100`F9d9 L15:`f`b

`B100`F9d9 eax=eax*a;`f`b

`B100`F9d9`f`b

`B100`F9d9 L2:`f`b

`B100`F9d9 return eax;`f`b

`B100`F9d9`f`b

`B100`F9d9 L14:`f`b

`B100`F9d9 eax = 1437600; /* = 1200*(1200-2) */`f`b

`B100`F9d9 b = 1200;`f`b

`B100`F9d9 goto L17;`f`b

`B100`F9d9 }`f`b

On peut remarquer par exemple que la fonction 'f' n'a pas été générée, mais que son code a directement été incorporé dans la fonction 'g' (le mot clef 'inline' permet de forcer ce type d'optimisation en `F33f`_`[C`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=C_(langage)]`_`f).

>>Notes et références

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f « We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. »

`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f (en) « Memory Optimization », sur redis.io (consulté le 25 mars 2020)

`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f (en) « Identifying bottlenecks and optimizing performance in a Python codebase », sur scoutapm.com (consulté le 12 septembre 2023)

`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f (en) « Profiling in Python (Detect CPU & memory bottlenecks) », sur likegeeks.com (consulté le 12 septembre 2023)

`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f (en) « Finding performance problems: profiling or logging? », sur pythonspeed.com (consulté le 12 septembre 2023)

`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f (en) « Optimization (computer science) », sur www.academickids.com (consulté le 12 septembre 2023)

`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f (en) « Code Assistant », sur www.gate2ai.com (consulté le 12 septembre 2023)

`:cite-note-8`!8.`! `F0af`_`[↑`#cite-ref-8]`_`f (en) « Improving Code Optimization with OpenAI Codex’s Neural Networks », sur ts2.space (consulté le 12 septembre 2023)

>>Voir aussi

• `F33f`_`[Optimisation de requête`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Optimisation_de_requête]`_`f

• `F33f`_`[Évaluation paresseuse`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Évaluation_paresseuse]`_`f

• `F33f`_`[Recherche de sous-expressions communes`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Recherche_de_sous-expressions_communes]`_`f

• `F33f`_`[Interprétation abstraite`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Interprétation_abstraite]`_`f

• `F33f`_`[LLVM`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=LLVM]`_`f

• `F33f`_`[Mémoire cache`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mémoire_cache]`_`f

• `F33f`_`[Mémoïsation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mémoïsation]`_`f

• `F33f`_`[Principe de localité`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Principe_de_localité_(informatique)]`_`f

• `F33f`_`[Simulation de phénomènes`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Simulation_de_phénomènes]`_`f

• `F33f`_`[Théorie des files d'attente`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Théorie_des_files_d'attente]`_`f

>>>Liens externes

• The Fallacy of Premature Optimization by Randall Hyde expliquant la citation de Donald Knuth et sa mauvaise interprétation

• Premature Optimization by Charles Cook sur cette même citation de Donald Knuth.

• Portail de la programmation informatique

`c`F0af`_`[↑ Back to top`#top]`_`f`a